home *** CD-ROM | disk | FTP | other *** search
/ Technotools / Technotools (Chestnut CD-ROM)(1993).ISO / lang_c / cug190 / bc.c < prev    next >
Text File  |  1985-11-14  |  17KB  |  861 lines
  1. /******************************************************************
  2.     bc.c, code building function of as68 assembler
  3. */
  4.  
  5. /*        (C) Copyright 1982 Steve Passe        */
  6. /*        All Rights Reserved                    */
  7.  
  8. /* version 1.00 */
  9. /* created 10/21/82 */
  10.  
  11. /* version 1.01
  12.  
  13.     8/30/83    ver. 1.01 modified for Aztec ver. 1.05g    smp
  14.  
  15. */
  16.  
  17. /* begincode */
  18.  
  19. /* includes */
  20.  
  21. #define AZTECZII 1
  22.  
  23. #ifndef AZTECZII
  24. #include <stdio.h>
  25. #else
  26. #include "stdio.h"                                /* with aztecII compiler */
  27. #endif
  28. #include "b:as68.h"
  29.  
  30. /* externals */
  31.  
  32. extern char pass;                            /* present pass number, 1 or 2 */
  33. extern unsigned line_count;                    /* line number of source file */
  34. extern long loc_counter;                    /* address to assemble obj code */
  35. extern int loc_plus;                        /* increment to loc counter */
  36. extern FLAG abs_long;                        /* default to absolute long add.*/
  37. extern FLAG rorg;                            /* in pc relative mode */
  38. extern char label[32];                    /* buffer for label from preparse */
  39. extern char instr[33];                    /* buffer for mnem, psdo or macro */
  40.  
  41. extern struct _mtable mtable[];                /* mnemonic lookup table */
  42. extern struct _mvalue mvalue[];                /* mnemonic code table */
  43. extern struct _oprnd op1, op2;                /* structs to hold operand val */
  44. extern char code[];                            /* code array */
  45.  
  46. p1_mnem(mt)
  47. struct _mtable *mt;
  48. {
  49.     int result, index;
  50.  
  51.     if ((index = match(mt)) == ERROR) {
  52. /** flush error stack someday? */
  53.         return ERROR;
  54.     }
  55.     switch (result = mvalue[index]._opc_len) {    /* determine code length... */
  56.     case 1:
  57.     case 2:
  58.     case 3:
  59.         break;
  60.     case 12:                                /* _imd not contained in opcode */
  61.     case 13:
  62.         result -= 10;                        /* strip '10' flag */
  63.         result += p1_codelen(&op2);            /* add second operand length */
  64.         break;
  65.     case 0:                                        /* gotta figure it out */
  66.         if (/**rorg**/ op1._rel_lbl && mvalue[index]._optyp1 == _sadr
  67.             && (op1._typ == _address || op1._typ == _d16_ani)) {
  68.             result = 2 + p1_codelen(&op2);        /* 1 for opcode, 1 for raddr */
  69.         }
  70.         else result = p1_codelen(&op1) + p1_codelen(&op2) + 1; /* 1 for code */
  71.         break;
  72.     }
  73.     loc_plus = result * 2;
  74.     return result;
  75. }
  76.  
  77. p1_codelen(op)
  78. struct _oprnd *op;
  79. {
  80.     int result;
  81.  
  82.     switch (op->_typ) {
  83.     case _address:
  84.         result = (op->_long_val) ? 2 : 1;
  85.         break;
  86.     case _d16_ani:
  87.     case _d8_anx:
  88.     case _labeli:
  89.     case _reglst:
  90.     case _label:    /* needed? */
  91.         result = 1;
  92.         break;
  93.     default:
  94.         result = 0;
  95.     }
  96.     return result;
  97. }
  98.  
  99. p2_mnem(mt)
  100. struct _mtable *mt;
  101. {
  102.     register int x;                                    /* scratch */
  103.     int index        ;                                /* index to mvalue */
  104.     int result;
  105.  
  106.     for (x = 0; x < 10; ++x) {            /* init code array to 0 */
  107.         code[x] = 0;
  108.     }
  109.     if ((index = match(mt)) == ERROR) {
  110.         dump_code(CODE, code, 0);
  111.         return ERROR;
  112.     }
  113.     code[0] = mvalue[index]._opcb1;                            /* get opcode */
  114.     code[1] = mvalue[index]._opcb2;                            /* get opcode */
  115.  
  116.     if ((result = (*mvalue[index]._p2_action)()) < 0) {        /* call funct */
  117.         err_out(result);
  118.         loc_plus = 0;
  119.     }
  120.     else loc_plus = ++result * 2;                    /* bytes created */
  121.     dump_code(CODE, code, loc_plus);                /* send them */
  122.     return result;                                    /* words created */
  123. }
  124.  
  125. match(mt)
  126. struct _mtable *mt;
  127. {
  128.     int index;                                        /* index to mvalue */
  129.     int type1, type2;                        /* operand types */
  130.  
  131.     if ((type1 = op_eval(&op1)) < 0) {                /* legal type found? */
  132.         err_out(BAD_OP1);            /* first op bad */
  133.     }
  134.     if ((type2 = op_eval(&op2)) < 0) {                /* second op? */
  135.         err_out(BAD_OP2);            /* no good */
  136.     }
  137.     if (type1 < 0 || type2 < 0) {
  138.         return ERROR;                            /* use NULL opcode */
  139.     }
  140.     if ((index = type_search(mt, type1, type2)) <=0) {
  141.         switch (index) {
  142.         case ILGL_OP1:
  143.             err_out(ILGL_OP1);            /* no good */
  144.             return ERROR;
  145.         case ILGL_OP2:
  146.             err_out(ILGL_OP2);            /* no good */
  147.             return ERROR;
  148.         default:
  149.             return ERROR;
  150.         }
  151.     }
  152.     return index;
  153. }
  154.  
  155. type_search(mt, type1, type2)
  156. struct _mtable *mt;
  157. int type1;
  158. int type2;
  159. {
  160.     register int x, y;                                /* count and index */
  161.     char t1, t2;                                    /* temp for array value */
  162.  
  163.     for (x = mt->_mvc, y = mt->_mvi; x; --x, ++y) {    /* search */
  164.                                             /* find op1 match... */
  165.         if (((t1 = mvalue[y]._optyp1) == type1)        /* if exact match */
  166.         || ((!(t1 & ~0xf0)) && (t1 & type1))) {    /* or classtyp and match */
  167.                                             /* search for second match */
  168.             for ( ; (mvalue[y]._optyp1 == t1) && x; --x, ++y) {
  169.                 if (((t2 = mvalue[y]._optyp2) == type2)    /* 2nd matches */
  170.                 || ((!(t2 & ~0xf0)) && (t2 & type2))) {    /* or typ & match */
  171.                     return y;                                /* found a match */
  172.                 }
  173.             }
  174.             return ILGL_OP2;
  175.         }
  176.     }
  177.     return ILGL_OP1;
  178. }
  179.  
  180.  
  181.  
  182. /* mask 3 bit immediate data from op1 over bits 3-1 of code [0] */
  183.  
  184. bbb(op)
  185. struct _oprnd *op;
  186. {
  187.     if (op->_data & ~7) return ERR_BBB;
  188.     code[0] |= (op->_data << 1);
  189.     return NULL;
  190. }
  191.  
  192. /* first ext word holds bit number (7/31) from first operand */
  193.  
  194. bbbx(size, op)
  195. int size;
  196. struct _oprnd *op;
  197. {
  198.     switch (size) {
  199.     case 3:
  200.         if (op->_data & ~7L) return ERR_BX3;                    /* range? */
  201.     case 5:
  202.         if (op->_data & ~31L) return ERR_BX5;
  203.         code[3] = op->_data;
  204.         return 1;                                            /* 1 ext word */
  205.     default:
  206.         return ERR_BX;
  207.     }
  208. }
  209.  
  210. /** mask bits 3-1 of first byte with op1, 8 = 00 */
  211.  
  212. ccc(op)
  213. struct _oprnd *op;
  214. {
  215.     if (op->_data < 1L || op->_data > 8L) return ERR_CCC;
  216.     code[0] |= (op->_data << 1) & 0x0f;
  217. /**    if (op->_data != 8L) code[0] |= op->_data << 1; **/
  218.  
  219.     return NULL;                                    /* no words added */
  220. }
  221.  
  222. /* mask bits 3-1 of first byte, or bits 2-0 of second, with op reg */
  223.  
  224. rsd(byt, op)
  225. int byt;
  226. struct _oprnd *op;
  227. {
  228.     code[byt] |= (byt) ? op->_reg : op->_reg << 1;
  229.     return NULL;
  230. }
  231.  
  232. /* register mask list from op into ext */
  233.  
  234. mmkk(order, op)
  235. char order;
  236. struct _oprnd *op;
  237. {
  238.     register int x;
  239.     unsigned u1 = 0;
  240.     unsigned m1 = 0x0001;
  241.     unsigned m2 = 0x8000;
  242.  
  243.     switch (order) {
  244.     case '>':
  245.         code[2] = op->_reg_list >> 8;                        /* high byte */
  246.         code[3] = op->_reg_list;                            /* low byte */
  247.         return 1;
  248.     case '<':
  249.  
  250.         for (x = 15; x >= 0; --x) {
  251.             u1 |= (op->_reg_list & (m1 << x)) ? (m2 >> x) : 0;
  252.         }
  253.  
  254.         code[2] = u1 >> 8;                        /* high byte */
  255.         code[3] = u1;                            /* low byte */
  256.         return 1;
  257.     default:
  258.         return ERR_MK;
  259.     }
  260. }
  261.  
  262. /* combined e, f, g, h, and j routines, 12/4/82 */
  263.  
  264. efghj(arg, i, op)
  265. char arg;
  266. int i;
  267. struct _oprnd *op;
  268. {
  269.     int len, displ;
  270.  
  271.     switch (op->_typ) {
  272.     case _ani:                                /* (an) */
  273.         if (arg == 'g') {
  274.             code[0] |= (op->_reg << 1);
  275.             code[1] |= 0x80;
  276.         }
  277.         else {
  278.             code[1] |= (0x10 | op->_reg);
  279.         }
  280.         return NULL;
  281.     case _pd_ani:                                /* -(an) */
  282.         switch (arg) {
  283.         case 'g':
  284.             code[0] |= (0x01 | op->_reg << 1);
  285.             return NULL;
  286.         case 'j': return ERR_J;
  287.         case 'h': return ERR_H;
  288.         default:
  289.             code[1] |= (0x20 | op->_reg);
  290.             return NULL;
  291.         }
  292.  
  293.     case _ani_pi:                                /* (an)+ */
  294.         switch (arg) {
  295.         case 'g':
  296.             code[0] |= (op->_reg << 1);
  297.             code[1] |= 0xc0;
  298.             return NULL;
  299.         case 'j': return ERR_J;
  300.         case 'h': return ERR_H;
  301.         default:
  302.             code[1] |= (0x18 | op->_reg);
  303.             return NULL;
  304.         }
  305.  
  306.     case _d16_ani:                                /* d16(an) */
  307.         switch (arg) {
  308.         case 'e':
  309.         case 'j':
  310.             if (/**rorg**/ op->_rel_lbl) {
  311.                 op->_ireg = op->_reg;                /* reg is an index */
  312.                 op->_iregtyp = op->_regtyp;            /* move type */
  313.                 op->_displ -= (loc_counter + 2);    /* make pc relative */
  314.                 code[1] |= 0x3b;
  315.                 return _d8_i(i, op);                /* indexed label */
  316.             }
  317.             break;
  318.         case 'g':
  319.             code[0] |= (0x01 | op->_reg << 1);
  320.             code[1] |= 0x40;
  321.             return _d16(i, op);
  322.         }
  323.         code[1] |= (0x28 | op->_reg);
  324.         return _d16(i, op);
  325.  
  326.     case _d8_anx:                                /* d8(an,i) */
  327.         if (arg == 'g') {
  328.             code[0] |= (0x01 | op->_reg << 1);
  329.             code[1] |= 0x80;
  330.         }
  331.         else {
  332.             code[1] |= (0x30 | op->_reg);
  333.         }
  334.         return _d8_i(i, op);
  335.  
  336.     case _address:        /* abs. add., short or long, or label if _rel_lbl */
  337.         switch (arg) {
  338.         case 'e':
  339.         case 'j':
  340.             if (/**rorg**/ op->_rel_lbl) {
  341.                 code[1] |= 0x3a;
  342.                 op->_displ = op->_addr - (loc_counter + 2);    /* rel. to pc */
  343.                 return _d16(i, op);                        /* finish as 'label' */
  344.             }
  345.             break;
  346.         case 'g':
  347.             code[1] |= 0xc0;
  348.             if (op->_long_val) {
  349.                 code[0] |= 0x03;
  350.                 code[i++] = op->_addr >> 24;
  351.                 code[i++] = op->_addr >> 16;
  352.                 len = 2;
  353.             }
  354.             else {
  355.                 code[0] |= (0x01);
  356.                 len = 1;
  357.             }
  358.             code[i++] = op->_addr >> 8;
  359.             code[i] = op->_addr;
  360.             return len;
  361.         }
  362.         if (op->_long_val) {
  363.             code[1] |= (0x39);
  364.             code[i++] = op->_addr >> 24;
  365.             code[i++] = op->_addr >> 16;
  366.             len = 2;
  367.         }
  368.         else {
  369.             code[1] |= (0x38);
  370.             len = 1;
  371.         }
  372.         code[i++] = op->_addr >> 8;
  373.         code[i] = op->_addr;
  374.         return len;
  375.  
  376.     case _label:                                /* relative label */
  377.         switch (arg) {
  378.         case 'g': return ERR_G;
  379.         case 'f': return ERR_F;
  380.         case 'h': return ERR_H;
  381.         default:
  382.             code[1] |= 0x3a;
  383.             op->_displ -= (loc_counter + 2);    /* rel. to pc */
  384.             return _d16(i, op);
  385.         }
  386.  
  387.     case _labeli:                                /* label(i) */
  388.         switch (arg) {
  389.         case 'g': return ERR_G;
  390.         case 'f': return ERR_F;
  391.         case 'h': return ERR_H;
  392.         default:
  393.             code[1] |= 0x3b;
  394.             op->_displ -= (loc_counter + 2);    /* rel. to pc */
  395.             return _d8_i(i, op);
  396.         }
  397.  
  398.     default:
  399.         return ERR_EFGHJ;
  400.     }
  401. }
  402.  
  403. _d16(i, op)
  404. int i;
  405. struct _oprnd *op;
  406. {
  407.     if ((op->_displ > 32767) || (op->_displ < -32768)) return ERR_D16;
  408.     code[i] = op->_displ >> 8;                        /* displacement... */
  409.     code[i+1] = op->_displ;                            /* ...into ext */
  410.     return 1;                                        /* 1 ext word returned */
  411. }
  412.  
  413. _d8_i(i, op)
  414. int i;
  415. struct _oprnd *op;
  416. {
  417.     if ((op->_displ > 127) || (op->_displ < -128)) return ERR_D8I;
  418.     if (op->_iregtyp == 'a') code[i] |= 0x80;        /* index is addr reg */
  419.     code[i] |= (op->_ireg << 4);                    /* add index reg # */
  420.     if (op->_inxl) code[i] |= 0x08;                    /* mark long index size */
  421.     code[i+1] = op->_displ;                            /* 8 bit displacement */
  422.     return 1;
  423. }
  424.  
  425. /* 8/16 bit address displacement */
  426.  
  427. xxxx(size, op)
  428. int size;
  429. struct _oprnd *op;
  430. {
  431.     int displ;
  432.  
  433.     switch (op->_typ) {
  434.     case _address:                                    /* absolute address */
  435.         displ = op->_addr - (loc_counter + 2);        /* make relative to pc */
  436.         break;
  437.     case _label:                                    /* relative address */
  438.         displ = op->_displ;
  439.         break;
  440.     default:                                        /* somethings wrong... */
  441.         return ERR_XXX;
  442.     }
  443.     switch (size) {
  444.         case 8:
  445.             if (displ > 127 || displ < -128) return ERR_XX;    /* check range */
  446.             code[1] |= displ;                            /* put into array */
  447.             return NULL;                                /* no ext word */
  448.         case 16:
  449.             if (displ > 32766 || displ < -32768) return ERR_XXXX; /* range */
  450.             code[2] = displ >> 8;
  451.             code[3] = displ;
  452.             return 1;                                /* 1 ext word returned */
  453.         default:
  454.             return ERR_XXX;
  455.     }
  456. }
  457.  
  458. /** */
  459.  
  460. yy(op)
  461. struct _oprnd *op;
  462. {
  463.     if (op->_data > 255L || op->_data < -128L) return ERR_Y;
  464.     code[1] = op->_data;
  465.     return NULL;                                /* no ext word */
  466. }
  467.  
  468. oyz(size, op)
  469. int size;
  470. struct _oprnd *op;
  471. {
  472.     switch (size) {
  473.     case 8:
  474.         if (op->_data > 255L || op->_data < -128L) return ERR_OY;
  475.         code[3] = op->_data;
  476.         return 1;                                /* one ext word added */
  477.     case 16:
  478.         if (op->_data > 65535L || op->_data < -32768L) return ERR_YY;
  479.         code[2] = op->_data >> 8;
  480.         code[3] = op->_data;
  481.         return 1;                                /* one ext word added */
  482.     case 32:
  483.         code[2] = op->_data >> 24;
  484.         code[3] = op->_data >> 16;
  485.         code[4] = op->_data >> 8;
  486.         code[5] = op->_data;
  487.         return 2;
  488.     default:
  489.         return ERR_OYZ;
  490.     }
  491. }
  492.  
  493. /*
  494. byte 1    byte 2    byte 3    byte 4    byte 5    byte 6    byte 7    byte 8    byte 9    byte 10
  495. */
  496.  
  497. /* none    none    */
  498.  
  499. nn()
  500. {
  501.     return NULL;                            /* no action required */
  502. }
  503.  
  504. /*    none    none    zero    yy    */
  505.  
  506. nnoy()
  507. {
  508.     return oyz(8, &op1);                    /* 8 bits imd data */
  509. }
  510.  
  511. /*    none    none        yyyy    */
  512.  
  513. nnyy()
  514. {
  515.     return oyz(16, &op1);                    /* 16 bits imd data */
  516. }
  517.  
  518. /*    none    xx    */
  519.  
  520. nx()
  521. {
  522.     return xxxx(8, &op1);                        /* 16 bit displ from op1 */
  523. }
  524.  
  525. /*    none    none        xxxx    */
  526.  
  527. nnxx()
  528. {
  529.     return xxxx(16, &op1);                        /* 16 bit displ from op1 */
  530. }
  531.  
  532. /*    none    ddd    */
  533.  
  534. nd()
  535. {
  536.     return rsd(1, &op1);                    /* dest reg from op1 into byte 1 */
  537. }
  538.  
  539. nd2()
  540. {
  541.     return rsd(1, &op2);                    /* dest reg from op2 into byte 1 */
  542. }
  543.  
  544. /*    none    ddd        zero    bbbbb    */
  545.  
  546. ndob()
  547. {
  548.     rsd(1, &op2);                            /* dest reg from op2 into byte 1 */
  549.     return bbbx(5, &op1);                    /* bit field spec into first ext */
  550. }
  551.  
  552. /*    none    ddd            kkkk    */
  553.  
  554. ndkk()
  555. {
  556.     rsd(1, &op2);                            /* dest reg from op2 into byte 1 */
  557.     return mmkk('<', &op1);                        /* reglist from op1 into ext */
  558. }
  559.  
  560. /*    none    ddd        zero    yy    */
  561.  
  562. ndoy()
  563. {
  564.     rsd(1, &op2);                            /* dest reg from op2 into byte 1 */
  565.     return oyz(8, &op1);                    /* 8 bits imd data */
  566. }
  567.  
  568. /*    none    ddd            yyyy    */
  569.  
  570. ndyy()
  571. {
  572.     rsd(1, &op2);                            /* dest reg from op2 into byte 1 */
  573.     return oyz(16, &op1);                    /* 16 bits of immediate data */
  574. }
  575.  
  576. /*    none    ddd            yyyy            zzzz    */
  577.  
  578. ndyz()
  579. {
  580.     rsd(1, &op2);                            /* dest reg from op2 into byte 1 */
  581.     return oyz(32, &op1);                    /* 32 bits of immediate data */
  582. }
  583.  
  584. /*    none    eeeeee        [ext]            [ext]    */
  585.  
  586. ne()
  587. {
  588.     return efghj('e', 2, &op1);
  589. }
  590.  
  591. /*    none    ffffff        [ext]            [ext]    */
  592.  
  593. nf()
  594. {
  595.     return efghj('f', 2, &op1);
  596. }
  597.  
  598. nf2()
  599. {
  600.     return efghj('f', 2, &op2);
  601. }
  602.  
  603. /*    none    ffffff    zero    bbb            [ext]            [ext]    */
  604.  
  605. nfob()
  606. {
  607.     bbbx(3, &op1);
  608.     return (efghj('f', 4, &op2) + 1);
  609. }
  610.  
  611. /*    none    ffffff    zero    yy            [ext]            [ext]    */
  612.  
  613. nfoy()
  614. {
  615.     oyz(8, &op1);                                /* 8 bits imd data */
  616.     return (efghj('f', 4, &op2) + 1);                /* op2 destination address */
  617. }
  618.  
  619. /*    none    ffffff        yyyy            [ext]            [ext]    */
  620.  
  621. nfyy()
  622. {
  623.     oyz(16, &op1);                                /* 16 bits imd data */
  624.     return (efghj('f', 4, &op2) + 1);                /* op2 destination address */
  625. }
  626.  
  627. /*    none    ffffff        yyyy            zzzz            [ext]        [ext] */
  628.  
  629. nfyz()
  630. {
  631.     oyz(32, &op1);                                /* 32 bits imd data */
  632.     return (efghj('f', 6, &op2) + 2);                /* op2 destination address */
  633. }
  634.  
  635. /*    none    hhhhhh        mmmm            [ext]            [ext]    */
  636.  
  637. nhmm()
  638. {
  639.     mmkk('>', &op1);                            /* reglist from op1 into ext */
  640.     return (efghj('h', 4, &op2) + 1);                /* op2 destination address */
  641. }
  642.  
  643. /*    none    jjjjjj        [ext]            [ext]    */
  644.  
  645. nj()
  646. {
  647.     return efghj('j', 2, &op1);
  648. }
  649.  
  650. /*    none    jjjjjj        mmmm            [ext]            [ext]    */
  651.  
  652. njmm()
  653. {
  654.     mmkk('>', &op2);                    /* reglist from op2 into ext */
  655.     return (efghj('j', 4, &op1) + 1);
  656. }
  657.  
  658. /*    none     rrr    */
  659.  
  660. nr()
  661. {
  662.     return rsd(1, &op1);                /* source reg from op1 into byte 1 */
  663. }
  664.  
  665. nr2()
  666. {
  667.     return rsd(1, &op2);                /* source reg from op2 into byte 1 */
  668. }
  669.  
  670. /*    none    rrr            xxxx    */
  671.  
  672. nrxx()
  673. {
  674.     rsd(1, &op1);                        /* source reg from op1 into byte 1 */
  675.     return xxxx(16, &op2);                /* 16 bit displ from op1 */
  676. }
  677.  
  678. /*    none    sss    [same as 'none rrr':nr()] */
  679.  
  680. /*    none    sss            mmmm    */
  681.  
  682. nsmm()
  683. {
  684.     rsd(1, &op1);                        /* source reg from op1 into byte 1 */
  685.     return mmkk('>', &op2);                /* reglist from op1 into ext */
  686. }
  687.  
  688. /*    none    vvvv    */
  689.  
  690. nv()
  691. {
  692.     if (op1._data & ~15l) return ERR_V;
  693.     code[1] |= op1._data;
  694.     return NULL;
  695. }
  696.  
  697. /*    bbb        ddd    */
  698.     /* same as ccc    ddd (sort of) */
  699.  
  700. /*    bbb        ffffff        [ext]            [ext]    */
  701.     /* bbb is a misnomer for these two... */
  702.  
  703. cf()
  704. {
  705.     ccc(&op1);
  706.     return efghj('f', 2, &op2);
  707. }
  708.  
  709. /*    ccc        ddd    */
  710.  
  711. cd()
  712. {
  713.     ccc(&op1);
  714.     return rsd(1, &op2);
  715. }
  716. /*    ddd        none    zero    yy    */
  717.  
  718. dnoy()
  719. {
  720.     rsd(0, &op2);
  721.     return oyz(8, &op1);                    /* 8 bits of immediate data */
  722. }
  723.  
  724. /*    ddd        none        yyyy    */
  725.  
  726. dnyy()
  727. {
  728.     rsd(0, &op2);
  729.     return oyz(16, &op1);                    /* 16 bits of immediate data */
  730. }
  731.  
  732. /*    ddd        none        yyyy            zzzz    */
  733.  
  734. dnyz()
  735. {
  736.     rsd(0, &op2);
  737.     return oyz(32, &op1);                    /* 32 bits of immediate data */
  738. }
  739.  
  740. /*    ddd        eeeeee        [ext]            [ext]    */
  741.  
  742. de()
  743. {
  744.     rsd(0, &op2);                            /* dest reg from op2 into byte 1 */
  745.     return efghj('e', 2, &op1);
  746. }
  747.  
  748. /*    ddd        jjjjjj        [ext]            [ext]    */
  749.  
  750. dj()
  751. {
  752.     rsd(0, &op2);
  753.     return efghj('j', 2, &op1);
  754. }
  755.  
  756. /*    ddd        rrr    */
  757.  
  758. dr()
  759. {
  760.     rsd(0, &op2);
  761.     return rsd(1, &op1);                /* source reg from op1 into byte 1 */
  762. }
  763.  
  764. /*    ddd        sss    [same as 'ddd rrr': dr()] */
  765.  
  766. /*    ddd        sss            xxxx    */
  767.  
  768. dsxx()
  769. {
  770.     rsd(0, &op2);
  771.     rsd(1, &op1);                    /* source reg from op1 into byte 1 */
  772.     return xxxx(16, &op1);                /* 16 bit displ from op1 */
  773. }
  774.  
  775. /*    ddd        yy    */
  776.  
  777. dy()
  778. {
  779.     rsd(0, &op2);
  780.     return yy(&op1);
  781. }
  782.  
  783. /*    gggggg    none    zero    yy            [ext]            [ext]    */
  784.  
  785. gnoy()
  786. {
  787.     oyz(8, &op1);                    /* 8 bits of immediate data */
  788.     return (efghj('g', 4, &op2) + 1);
  789. }
  790.  
  791. /*    gggggg    none        yyyy            [ext]            [ext]    */
  792.  
  793. gnyy()
  794. {
  795.     oyz(16, &op1);                    /* 16 bits of immediate data */
  796.     return (efghj('g', 4, &op2) + 1);
  797. }
  798.  
  799. /*    gggggg    none        yyyy            zzzz            [ext]        [ext]    */
  800.  
  801. gnyz()
  802. {
  803.     oyz(32, &op1);                    /* 32 bits of immediate data */
  804.     return (efghj('g', 6, &op2) + 2);
  805. }
  806.  
  807. /*    gggggg    eeeeee        [exts]            [exts]            [extd]        [extd]    */
  808.  
  809. ge()
  810. {
  811.     int temp;
  812.     temp = efghj('e', 2, &op1);
  813.     return (efghj('g', 2 + (temp * 2), &op2) + temp);
  814. }
  815.  
  816. /*    gggggg    sss            [ext]            [ext]    */
  817.  
  818. gs()
  819. {
  820.     rsd(1, &op1);
  821.     return efghj('g', 2, &op2);
  822. }
  823.  
  824. /*    rrr        ddd    */
  825.  
  826. rd()
  827. {
  828.     rsd(0, &op1);
  829.     return rsd(1, &op2);
  830. }
  831.  
  832. /*    rrr        ffffff        [ext]            [ext]    */
  833.  
  834. rf()
  835. {
  836.     rsd(0, &op1);
  837.     return efghj('f', 2, &op2);
  838. }
  839.  
  840. /*    sss        ddd    [same as 'rrr ddd': rd()] */
  841.  
  842. /*    sss        ddd            xxxx    */
  843.  
  844. sdxx()
  845. {
  846.     rsd(0, &op1);                        /* source reg from op1 into byte 1 */
  847.     rsd(1, &op2);
  848.     return xxxx(16, &op2);                /* 16 bit displ from op2 */
  849. }
  850.  
  851. /*    sss        ffffff        [ext]            [ext] */
  852.  
  853. sf()
  854. {
  855.     rsd(0, &op1);                        /* source reg from op1 into byte 0 */
  856.     return efghj('f', 2, &op2);
  857. }
  858.  
  859. /* endcode */
  860. 16 bits of immediate data */
  861.     return (efghj('g',